// limits standard header
#pragma once
#ifndef _LIMITS_
#define _LIMITS_
#ifndef RC_INVOKED
#include <ymath.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cwchar>
#include <xstddef>

#ifdef _MSC_VER
 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
#endif  /* _MSC_VER */

_STD_BEGIN

//	ASSUMES:
//	wraparound 2's complement integer arithmetic w/o traps
//	all CHAR_BITs of each byte used by integers
//	IEC559 (IEEE 754) floating-point arithmetic
//	floating-point errors can trap
//	tinyness detected before floating-point rounding
//	64-bit long long (if _LONGLONG defined)

		// ENUM float_denorm_style
typedef enum
	{	// constants for different IEEE float denormalization styles
	denorm_indeterminate = -1,
	denorm_absent = 0,
	denorm_present = 1}
		float_denorm_style;

		// ENUM float_round_style
typedef enum
	{	// constants for different IEEE rounding styles
	round_indeterminate = -1,
	round_toward_zero = 0,
	round_to_nearest = 1,
	round_toward_infinity = 2,
	round_toward_neg_infinity = 3}
		float_round_style;

		// STRUCT _Num_base
struct _CRTIMP2_PURE _Num_base
	{	// base for all types, with common defaults
	_STCONS(float_denorm_style, has_denorm, denorm_absent);
	_STCONS(bool, has_denorm_loss, false);
	_STCONS(bool, has_infinity, false);
	_STCONS(bool, has_quiet_NaN, false);
	_STCONS(bool, has_signaling_NaN, false);
	_STCONS(bool, is_bounded, false);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, false);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, false);
	_STCONS(bool, is_specialized, false);
	_STCONS(bool, tinyness_before, false);
	_STCONS(bool, traps, false);
	_STCONS(float_round_style, round_style, round_toward_zero);
	_STCONS(int, digits, 0);
	_STCONS(int, digits10, 0);
	_STCONS(int, max_exponent, 0);
	_STCONS(int, max_exponent10, 0);
	_STCONS(int, min_exponent, 0);
	_STCONS(int, min_exponent10, 0);
	_STCONS(int, radix, 0);
	};

_STCONSDEF(_Num_base, float_denorm_style, has_denorm)
_STCONSDEF(_Num_base, bool, has_denorm_loss)
_STCONSDEF(_Num_base, bool, has_infinity)
_STCONSDEF(_Num_base, bool, has_quiet_NaN)
_STCONSDEF(_Num_base, bool, has_signaling_NaN)
_STCONSDEF(_Num_base, bool, is_bounded)
_STCONSDEF(_Num_base, bool, is_exact)
_STCONSDEF(_Num_base, bool, is_iec559)
_STCONSDEF(_Num_base, bool, is_integer)
_STCONSDEF(_Num_base, bool, is_modulo)
_STCONSDEF(_Num_base, bool, is_signed)
_STCONSDEF(_Num_base, bool, is_specialized)
_STCONSDEF(_Num_base, bool, tinyness_before)
_STCONSDEF(_Num_base, bool, traps)
_STCONSDEF(_Num_base, float_round_style, round_style)
_STCONSDEF(_Num_base, int, digits)
_STCONSDEF(_Num_base, int, digits10)
_STCONSDEF(_Num_base, int, max_exponent)
_STCONSDEF(_Num_base, int, max_exponent10)
_STCONSDEF(_Num_base, int, min_exponent)
_STCONSDEF(_Num_base, int, min_exponent10)
_STCONSDEF(_Num_base, int, radix)

		// TEMPLATE CLASS numeric_limits
template<class _Ty>
	class numeric_limits
		: public _Num_base
	{	// numeric limits for arbitrary type _Ty (say little or nothing)
public:
	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (_Ty(0));
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (_Ty(0));
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (_Ty(0));
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (_Ty(0));
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (_Ty(0));
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (_Ty(0));
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (_Ty(0));
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (_Ty(0));
		}
	};

		// STRUCT _Num_int_base
struct _CRTIMP2_PURE _Num_int_base
	: public _Num_base
	{	// base for integer types
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, true);
	_STCONS(bool, is_integer, true);
	_STCONS(bool, is_modulo, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(int, radix, 2);
	};

_STCONSDEF(_Num_int_base, bool, is_bounded)
_STCONSDEF(_Num_int_base, bool, is_exact)
_STCONSDEF(_Num_int_base, bool, is_integer)
_STCONSDEF(_Num_int_base, bool, is_modulo)
_STCONSDEF(_Num_int_base, bool, is_specialized)
_STCONSDEF(_Num_int_base, int, radix)

		// STRUCT _Num_float_base
struct _CRTIMP2_PURE _Num_float_base
	: public _Num_base
	{	// base for floating-point types
	_STCONS(float_denorm_style, has_denorm, denorm_present);
	_STCONS(bool, has_denorm_loss, true);
	_STCONS(bool, has_infinity, true);
	_STCONS(bool, has_quiet_NaN, true);
	_STCONS(bool, has_signaling_NaN, true);
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, true);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(bool, tinyness_before, true);
	_STCONS(bool, traps, true);
	_STCONS(float_round_style, round_style, round_to_nearest);
	_STCONS(int, radix, FLT_RADIX);
	};

_STCONSDEF(_Num_float_base, float_denorm_style, has_denorm)
_STCONSDEF(_Num_float_base, bool, has_denorm_loss)
_STCONSDEF(_Num_float_base, bool, has_infinity)
_STCONSDEF(_Num_float_base, bool, has_quiet_NaN)
_STCONSDEF(_Num_float_base, bool, has_signaling_NaN)
_STCONSDEF(_Num_float_base, bool, is_bounded)
_STCONSDEF(_Num_float_base, bool, is_exact)
_STCONSDEF(_Num_float_base, bool, is_iec559)
_STCONSDEF(_Num_float_base, bool, is_integer)
_STCONSDEF(_Num_float_base, bool, is_modulo)
_STCONSDEF(_Num_float_base, bool, is_signed)
_STCONSDEF(_Num_float_base, bool, is_specialized)
_STCONSDEF(_Num_float_base, bool, tinyness_before)
_STCONSDEF(_Num_float_base, bool, traps)
_STCONSDEF(_Num_float_base, float_round_style, round_style)
_STCONSDEF(_Num_float_base, int, radix)

		// CLASS numeric_limits<char>
template<> class _CRTIMP2_PURE numeric_limits<char>
	: public _Num_int_base
	{	// limits for type char
public:
	typedef char _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (CHAR_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (CHAR_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, CHAR_MIN != 0);
	_STCONS(int, digits, CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0))
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<char>, bool, is_signed)
_STCONSDEF(numeric_limits<char>, int, digits)
_STCONSDEF(numeric_limits<char>, int, digits10)

 #ifdef _NATIVE_WCHAR_T_DEFINED
		// CLASS numeric_limits<wchar_t>
template<> class _CRTIMP2_PURE numeric_limits<wchar_t>
	: public _Num_int_base
	{	// limits for type wchar_t
public:
	typedef wchar_t _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return ((_Ty)WCHAR_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return ((_Ty)WCHAR_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, WCHAR_MIN != 0);
	_STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0)) * 301L / 1000);
	};
 
_STCONSDEF(numeric_limits<wchar_t>, bool, is_signed)
_STCONSDEF(numeric_limits<wchar_t>, int, digits)
_STCONSDEF(numeric_limits<wchar_t>, int, digits10)
 #endif /* _NATIVE_WCHAR_T_DEFINED */

		// CLASS numeric_limits<_Bool>
template<> class _CRTIMP2_PURE numeric_limits<_Bool>
	: public _Num_int_base
	{	// limits for type bool
public:
	typedef bool _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (false);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (true);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, 1);
	_STCONS(int, digits10, 0);
	};

_STCONSDEF(numeric_limits<_Bool>, bool, is_modulo)
_STCONSDEF(numeric_limits<_Bool>, bool, is_signed)
_STCONSDEF(numeric_limits<_Bool>, int, digits)
_STCONSDEF(numeric_limits<_Bool>, int, digits10)

		// CLASS numeric_limits<signed char>
template<> class _CRTIMP2_PURE numeric_limits<signed char>
	: public _Num_int_base
	{	// limits for type signed char
public:
	typedef signed char _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (SCHAR_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (SCHAR_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT - 1);
	_STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);
	};

_STCONSDEF(numeric_limits<signed char>, bool, is_signed)
_STCONSDEF(numeric_limits<signed char>, int, digits)
_STCONSDEF(numeric_limits<signed char>, int, digits10)

		// CLASS numeric_limits<unsigned char>
template<> class _CRTIMP2_PURE numeric_limits<unsigned char>
	: public _Num_int_base
	{	// limits for type unsigned char
public:
	typedef unsigned char _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (0);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (UCHAR_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT);
	_STCONS(int, digits10, (CHAR_BIT) * 301L / 1000);
	};

_STCONSDEF(numeric_limits<unsigned char>, bool, is_signed)
_STCONSDEF(numeric_limits<unsigned char>, int, digits)
_STCONSDEF(numeric_limits<unsigned char>, int, digits10)

		// CLASS numeric_limits<short>
template<> class _CRTIMP2_PURE numeric_limits<short>
	: public _Num_int_base
	{	// limits for type short
public:
	typedef short _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (SHRT_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (SHRT_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1)
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<short>, bool, is_signed)
_STCONSDEF(numeric_limits<short>, int, digits)
_STCONSDEF(numeric_limits<short>, int, digits10)

		// CLASS numeric_limits<unsigned short>
template<> class _CRTIMP2_PURE numeric_limits<unsigned short>
	: public _Num_int_base
	{	// limits for type unsigned short
public:
	typedef unsigned short _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (0);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (USHRT_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short))
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<unsigned short>, bool, is_signed)
_STCONSDEF(numeric_limits<unsigned short>, int, digits)
_STCONSDEF(numeric_limits<unsigned short>, int, digits10)

		// CLASS numeric_limits<int>
template<> class _CRTIMP2_PURE numeric_limits<int>
	: public _Num_int_base
	{	// limits for type int
public:
	typedef int _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (INT_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (INT_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1)
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<int>, bool, is_signed)
_STCONSDEF(numeric_limits<int>, int, digits)
_STCONSDEF(numeric_limits<int>, int, digits10)

		// CLASS numeric_limits<unsigned int>
template<> class _CRTIMP2_PURE numeric_limits<unsigned int>
	: public _Num_int_base
	{	// limits for type unsigned int
public:
	typedef unsigned int _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (0);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (UINT_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int))
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<unsigned int>, bool, is_signed)
_STCONSDEF(numeric_limits<unsigned int>, int, digits)
_STCONSDEF(numeric_limits<unsigned int>, int, digits10)

		// CLASS numeric_limits<long>
template<> class _CRTIMP2_PURE numeric_limits<long>
	: public _Num_int_base
	{	// limits for type long
public:
	typedef long _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (LONG_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (LONG_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1)
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<long>, bool, is_signed)
_STCONSDEF(numeric_limits<long>, int, digits)
_STCONSDEF(numeric_limits<long>, int, digits10)

		// CLASS numeric_limits<unsigned long>
template<> class _CRTIMP2_PURE numeric_limits<unsigned long>
	: public _Num_int_base
	{	// limits for type unsigned long
public:
	typedef unsigned long _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (0);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (ULONG_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long))
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<unsigned long>, bool, is_signed)
_STCONSDEF(numeric_limits<unsigned long>, int, digits)
_STCONSDEF(numeric_limits<unsigned long>, int, digits10)

 #ifdef _LONGLONG
		// CLASS numeric_limits<_LONGLONG>
template<> class _CRTIMP2_PURE numeric_limits<_LONGLONG>
	: public _Num_int_base
	{	// limits for type long long
public:
	typedef _LONGLONG _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (-_LLONG_MAX - _C2);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (_LLONG_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1)
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<_LONGLONG>, bool, is_signed)
_STCONSDEF(numeric_limits<_LONGLONG>, int, digits)
_STCONSDEF(numeric_limits<_LONGLONG>, int, digits10)

		// CLASS numeric_limits<_ULONGLONG>
template<> class _CRTIMP2_PURE numeric_limits<_ULONGLONG>
	: public _Num_int_base
	{	// limits for type unsigned long long
public:
	typedef _ULONGLONG _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (0);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (_ULLONG_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (0);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (0);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (0);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (0);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (0);
		}

	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG))
		* 301L / 1000);
	};

_STCONSDEF(numeric_limits<_ULONGLONG>, bool, is_signed)
_STCONSDEF(numeric_limits<_ULONGLONG>, int, digits)
_STCONSDEF(numeric_limits<_ULONGLONG>, int, digits10)

 #endif /* _LONGLONG */

		// CLASS numeric_limits<float>
template<> class _CRTIMP2_PURE numeric_limits<float>
	: public _Num_float_base
	{	// limits for type float
public:
	typedef float _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (FLT_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (FLT_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (FLT_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (::_FDenorm._Float);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (::_FInf._Float);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (::_FNan._Float);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (::_FSnan._Float);
		}

	_STCONS(int, digits, FLT_MANT_DIG);
	_STCONS(int, digits10, FLT_DIG);
	_STCONS(int, max_exponent, (int)FLT_MAX_EXP);
	_STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)FLT_MIN_EXP);
	_STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);
	};

_STCONSDEF(numeric_limits<float>, int, digits)
_STCONSDEF(numeric_limits<float>, int, digits10)
_STCONSDEF(numeric_limits<float>, int, max_exponent)
_STCONSDEF(numeric_limits<float>, int, max_exponent10)
_STCONSDEF(numeric_limits<float>, int, min_exponent)
_STCONSDEF(numeric_limits<float>, int, min_exponent10)

		// CLASS numeric_limits<double>
template<> class _CRTIMP2_PURE numeric_limits<double>
	: public _Num_float_base
	{	// limits for type double
public:
	typedef double _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (DBL_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (DBL_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (DBL_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (::_Denorm._Double);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (::_Inf._Double);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (::_Nan._Double);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (::_Snan._Double);
		}

	_STCONS(int, digits, DBL_MANT_DIG);
	_STCONS(int, digits10, DBL_DIG);
	_STCONS(int, max_exponent, (int)DBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)DBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);
	};

_STCONSDEF(numeric_limits<double>, int, digits)
_STCONSDEF(numeric_limits<double>, int, digits10)
_STCONSDEF(numeric_limits<double>, int, max_exponent)
_STCONSDEF(numeric_limits<double>, int, max_exponent10)
_STCONSDEF(numeric_limits<double>, int, min_exponent)
_STCONSDEF(numeric_limits<double>, int, min_exponent10)

		// CLASS numeric_limits<long double>
template<> class _CRTIMP2_PURE numeric_limits<long double>
	: public _Num_float_base
	{	// limits for type long double
public:
	typedef long double _Ty;

	static _Ty (__CRTDECL min)() _THROW0()
		{	// return minimum value
		return (LDBL_MIN);
		}

	static _Ty (__CRTDECL max)() _THROW0()
		{	// return maximum value
		return (LDBL_MAX);
		}

	static _Ty __CRTDECL epsilon() _THROW0()
		{	// return smallest effective increment from 1.0
		return (LDBL_EPSILON);
		}

	static _Ty __CRTDECL round_error() _THROW0()
		{	// return largest rounding error
		return (0.5);
		}

	static _Ty __CRTDECL denorm_min() _THROW0()
		{	// return minimum denormalized value
		return (::_LDenorm._Long_double);
		}

	static _Ty __CRTDECL infinity() _THROW0()
		{	// return positive infinity
		return (::_LInf._Long_double);
		}

	static _Ty __CRTDECL quiet_NaN() _THROW0()
		{	// return non-signaling NaN
		return (::_LNan._Long_double);
		}

	static _Ty __CRTDECL signaling_NaN() _THROW0()
		{	// return signaling NaN
		return (::_LSnan._Long_double);
		}

	_STCONS(int, digits, LDBL_MANT_DIG);
	_STCONS(int, digits10, LDBL_DIG);
	_STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
	_STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
	_STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
	_STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
	};

_STCONSDEF(numeric_limits<long double>, int, digits)
_STCONSDEF(numeric_limits<long double>, int, digits10)
_STCONSDEF(numeric_limits<long double>, int, max_exponent)
_STCONSDEF(numeric_limits<long double>, int, max_exponent10)
_STCONSDEF(numeric_limits<long double>, int, min_exponent)
_STCONSDEF(numeric_limits<long double>, int, min_exponent10)

_STD_END
#ifdef _MSC_VER
 #pragma warning(pop)
 #pragma pack(pop)
#endif  /* _MSC_VER */

#endif /* RC_INVOKED */
#endif /* _LIMITS_ */

/*
 * Copyright (c) 1992-2006 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
 V5.02:0009 */
